﻿#define  _CRT_SECURE_NO_WARNINGS
//关于#define  _CRT_SECURE_NO_WARNINGS的设置，利用everthing软件来设置，以后建立新文件就会包含，peng
//qq截图 打开qq设置快捷键即可，使用自己熟练的。

//1. 每个源⽂件(.c)单独经过编译器处理⽣成对应的⽬标⽂件(.obj为后缀的⽂件)
//2. 多个⽬标⽂件和库⽂件经过链接器处理⽣成对应的可执⾏程序(.exe⽂件)
//msvc、clang、gcc 就是⼀些常⻅的编译器，当然也有⼀些集成开发环境 如：VS2022、
//XCode、CodeBlocks、DevC++、Clion 等。
//main函数有且仅有⼀个，出现多个就会出现错误。
//键盘上敲出来的为字符，在编译器中为ASCII值
//65~90为A~Z，97~122为a~z
//对应的⼤⼩写字符(a和A)的ASCII码值的差值是32
//数字字符0~9的ASCII码值从48~57
//%c为打印字符。''单引号括起来的为字符，""双引号括起来的为字符串
//C语⾔字符串中⼀个特殊的知识，就是在字符串的末尾隐藏放着⼀个 \0 字符，这个 \0 字符是字符串
//的结束标志。
//#include <stdio.h>
//int main()
//{
//	char arr1[] = { 'a', 'b', 'c','\0'};//arr1数组中存放3个字符
//	char arr2[] = "abc"; //arr2数组中存放字符串
//	printf("%s\n", arr1);
//	printf("%s\n", arr2);
//	return 0;
//}//加个\0不会出现糖糖糖
//转义字符为加\转变原有的意义
 /*\? ：在书写连续多个问号时使⽤，防⽌他们被解析成三字⺟词，在新的编译器上没法验证了。
• \' ：⽤于表⽰字符常量'
• \" ：⽤于表⽰⼀个字符串内部的双引号
• \\ ：⽤于表⽰⼀个反斜杠，防⽌它被解释为⼀个转义序列符。
• \a ：警报，这会使得终端发出警报声或出现闪烁，或者两者同时发⽣。
• \b ：退格键，光标回退⼀个字符，但不删除字符。
• \f ：换⻚符，光标移到下⼀⻚。在现代系统上，这已经反映不出来了，⾏为改成类似于 \v 。
• \n ：换⾏符。
• \r ：回⻋符，光标移到同⼀⾏的开头。
• \t ：制表符，光标移到下⼀个⽔平制表位，通常是下⼀个4 / 8的倍数。
• \v ：垂直分隔符，光标移到下⼀个垂直制表位，通常是下⼀⾏的同⼀列。*/
//是这是 C99 标准新增的语法。不管是哪⼀种注释，都不能放在双引号⾥⾯。
//char //character
//[signed] char //有符号的
//unsigned char //⽆符号的
////短整型
//short[int]
//[signed] short[int]
//unsigned short[int]
////整型
//int
//[signed] int
//unsigned int
////⻓整型
//long[int]
//[signed] long[int]
//unsigned long[int]
////更⻓的整型
////C99中引⼊
//long long[int]
//[signed] long long[int]
//unsigned long long[int]；
//布尔类型的使⽤得包含头⽂件 <stdbool.h>
//_Bool flag = true;
//if (flag)
//printf("i like C\n");
//sizeof 操作符的操作数可以是类型，也可是变量或者表达式。
#include <stdio.h>
//int main()
//{
//	int a = 10;
//	printf("%zd\n", sizeof(a));
//	printf("%zd\n", sizeof a);//a是变量的名字，可以省略掉sizeof后边的()
//	printf("%zd\n", sizeof(int));
//	printf("%zd\n", sizeof(3 + 3.5));
//	return 0;
//}
#include <stdio.h>
#include <stdbool.h>
//int main()
//{
//	printf("%zd\n", sizeof(char));
//	printf("%zd\n", sizeof(_Bool));
//	printf("%zd\n", sizeof(short));
//	printf("%zd\n", sizeof(int));
//	printf("%zd\n", sizeof(long));
//	printf("%zd\n", sizeof(long long));
//	printf("%zd\n", sizeof(float));
//	printf("%zd\n", sizeof(double));
//	printf("%zd\n", sizeof(long double));//在vs上是8个字节，在gcc上测试是16
//	return 0;
//}
//limits.h ⽂件中说明了整型类型的取值范围。
//float.h 这个头⽂件中说明浮点型类型的取值范围。
//变量的命名
//• 只能由字⺟（包括⼤写和⼩写）、数字和下划线（`_`）组成。
//• 不能以数字开头。
//• ⻓度不能超过63个字符。
//• 变量名中区分⼤⼩写的。
//• 变量名不能使⽤关键字。
//
//其实当局部变量和全局变量同名的时候，局部变量优先使⽤。*
//
//内存中的三个区域：栈区、堆区、静态区。
//1. 局部变量是放在内存的栈区
//2. 全局变量是放在内存的静态区
//3. 堆区是⽤来动态内存管理的
//
//int a = (int)3.14;//意思是将3.14强制类型转换为int类型，这种强制类型转换只取整数部分
//
//scanf 函数必须包含第一行文件，否则会出现风险错误提示，
//scanf函数可以处理多个占位符，
/*#include <stdio.h>
int main()
{
	int a = 0;
	int b = 0;
	float f = 0.0f;
	int r = scanf("%d %d %f", &a, &b, &f);
	printf("a=%d b=%d f=%f\n", a, b, f);
	printf("r = %d\n", r);
	return 0;
}      */   
#include <stdio.h>
//int main()
//{
//	int a, b, c;
//	a = 5;
//	c = ++a;
//	b = ++c, c++, ++a, a++;
//	b += a++ + c;//a先和c加，结果为16，在加上b的值7，比的结果为23，最后给a加1，a的值为9
//	printf("a = %d b = %d c = %d\n:", a, b, c);
//	return 0;
//}
//#include <stdio.h>
//
//int main()
//{
//	int a = 0;
//	int b = 0;
//	while (scanf("%d%d", &a, &b) != EOF)//输入两个占位符，使用ctrl+z,取下读取
//	{
//		if (a<b)
//			printf("%d<%d\n", a, b);
//		else if (a > b)
//			printf("%d>%d\n", a, b);
//		else
//			printf("%d=%d\n", a, b);
//	}
//	return 0;
//}
//int main()
//{
//	int a = 0;
//	int b = 0;
//	while (scanf("%d%d", &a, &b) != EOF)
//	{
//		if (a > b)
//			printf("%d>%d\n", a, b);
//		else if (a < b)
//			printf("%d<%d\n",a, b);
//		else
//			printf("%d=%d\n", a,b);
//	}
//	return 0;
//}
//printf 函数的第一个参数是一个格式化字符串（format string），它指定了输出的格式。格式化字符串可以包含普通字符和格式说明符（format specifiers），格式说明符以 % 开头，用于指定后续参数的类型和输出格式。
#include <stdlib.h>
#include <windows.h>
//void menu()
//{
//	printf("*****1.play   2.exit*********");
//}
//void game()
//{
//	int guess = 0;
//	int ret = rand() % 100 + 1;
//	
//	while (1)
//	{
//		printf("请猜数字->");
//		scanf("%d", &guess);
//		if (guess > ret)
//		{
//			printf("猜大了\n");
//
//		}
//		else if (guess < ret)
//		{
//			printf("猜小了\n");
//		}
//		else
//		{
//			printf("猜对了\n");
//			break;
//		}
//	}
//}
//
//int main()
//{
//	int input = 0;
//	do
//	{
//		menu();
//		printf("请输入数字开始游戏->");
//			scanf("%d", &input);
//		switch (input)//switch对input的值进行判断；
//		{
//		case 1:
//			game();
//				break;
//		case 2:
//			printf("退出游戏！\n");
//				break;
//		default:
//			printf("输入错误，请重新输入\n");
//		}
//		
//	}
//	while (input);
//
//	return 0;
//}
//int main()
//{
//	int i = 1;
//	sizeof(i++);
//	printf("%d\n", i);
//
//
//
//	return 0;
//
//}
//int main()
//{
//	int a = 0;
//	int b = 0;
//	while (scanf("%d %d", &a, &b) != -1)//在 Windows 系统中，按下 Ctrl + Z 然后按 Enter 键表示输入 EOF，EOF的编码值为-1
//	{
//		if (a == b)//用 while 循环不断从标准输入读取整数，直到遇到 EOF 为止。
//		{
//			printf("%d=%d\n", a, b);
//		}
//		else if (a > b)
//		{
//			printf("%d>%d\n", a, b);
//		}
//		else
//		{
//			printf("%d<%d\n", a, b);
//		}
//	}
//	return 0;
//}

/*intmain() {

	int input = 0;
	while (scanf("%d", &input) != EOF)
	{
		if (input > 0)
		{
			printf("1\n");
		}
		else if (input < 0)
		{
			printf("0\n");

		}
		else
		{
			printf("0.5\n");
		}

	}

	return 0;*/
/*}*///文件结束符（EOF）：在不同的操作系统中，输入文件结束符的方式不同。在 Windows 系统中，可以通过按下 Ctrl + Z 再按回车键来输入文件结束符；在 Linux 或 macOS 系统中，可以通过按下 Ctrl + D 来输入文件结束符。
//输入格式：代码要求输入的必须是有效的整数。如果输入的不是整数，scanf 函数可能会出现错误，导致程序行为异常。例如，如果输入字母或其他非数字字符，scanf 可能无法正确读取，并且后续的输入读取会受到影响。
//
//int main()
//{
//	printf("printf");
//	return 0;
//}
#include <stdio.h>

//int main() {
//	int i = 0;
//	int k = 0;
//	int j = 0;
//	while (scanf("%d", &i) != EOF)
//	{
//		for (k = 1; k <= i; k++)
//		{
//			for (j = 1; j <= k; j++)
//			{
//				printf("* ");
//			}
//			printf("\n");
//		}
//	}
//	return 0;
//}
//int main()
//{
//	int a = 0;
//	for (a = 1; a<=100; a++) 
//	{
//		if (a % 3 == 0)
//		{
//			printf(" %d", a);
//		}
//	}
//	return 0;
//}
 

//int main()
//{
//
//	int a = 0;
//	int b = 0;
//	int c = 0;
//	while(scanf("%d %d %d", &a, &b, &c) != EOF)
//	{
//		if (a > b && b > c)
//		{
//			printf("%d %d %d", a, b, c);
//		}
//		else if (a > b&& c > b)
//
//		{
//			printf("%d %d %d", a, c, b);
//		}
//		else if (b > a && a > c)
//		{
//			printf("%d %d %d", b, a, c);
//		}
//		else if(b>c&&c>a)
//		{
//			printf("%d %d %d", b, c, a);
//		}
//		else if (c > b && a > b)
//		{
//			printf("%d %d %d", c, a, b);
//		}
//		else
//		{
//			printf(" %d %d %d", c, b, a);
//		}
//		
//	}
//	return 0;
//
//}
//if 语句中0表示假，非零表示真；   两个字符串是否相等不能使用==，应该使用strcmp函数。。。
//&& 短路的时候，&& 的左边操作数为假，右边不再计算。  
//.|| 操作符的两个操作数只要有一个是真，则表达式结果为真


//
//int main() {
//	int a = 0;
//	int b = 0;
//	int c = 0;
//	while (scanf("%d", &a) != EOF)
//	{
//		for (b = a; b >0; b--)
//		{
//			for (c = 0; c < b; c++)//等于四的时候还可以加
//			{
//				printf("* ");
//			}
//			printf("\n");
//		}
//	}
//
//	return 0;
//}

//int main()
//
//{
//	int n = 0;
//	while (scanf("%d", &n) != EOF)
//	{
//		//控制行数
//		int i = 0;
//		for (i = 0; i < n; i++)
//
//		{
//			//控制每行的两个空格 + 一个空格和一颗*
//			int j = 0;
//			for (j = 0; j < n - 1 - i; j++)
//			{
//				printf("  ");
//			}
//			for (j = 0; j <= i; j++)
//			{
//				printf("* ");
//			}
//			printf("\n");
//		}
//
//	}
//	return 0;
//}


//int main() {
//	int a = 0;
//	int b = 0;
//	int c = 0;
//	while (scanf("%d", &a) != EOF)
//	{
//		for (b = 0; b < a; b++)//控制行数
//		{
//			for (c = 0; c < a - 1 - b; c++)
//			{
//				printf(" ");
//			}
//			for (c = 0; c <= b; c++)
//			{
//				printf("* ");
//			}
//			printf("\n");
//		}
//	}
//	return 0;
//}

//int main()
//{
//	int a = 0;
//	int b = 2;
//	if (a == 1)//悬空else,不会输出，因为判断为错误；
//		if (b == 2)
//			printf("hehe\n");
//		else
//			printf("haha\n");
//	return 0;
//}


//#include <stdio.h>
//
//int main() {
//	int n = 0;
//	while ((scanf("%d", &n)) != EOF)
//	{
//		for (int i = 0; i < n; i++)
//		{
//			for (int j = 0; j < n - i; j++)
//			{
//				printf(" ");
//			}
//			for (int k = i + 1; k > 0; k--)
//			{
//				printf("* ");
//			}
//			printf("\n");
//		}
//		for (int i = 0; i < n + 1; i++)
//		{
//			for (int j = i; j > 0; j--)
//			{
//				printf(" ");
//			}
//			for (int k = n + 1 - i; k > 0; k--)
//			{
//				printf("* ");
//			}
//			printf("\n");
//		}
//	}
//
//	return 0;
//}

//int main()
//
//{
//    int n = 0;
//    while (scanf("%d", &n) != EOF)
//    {
//        int i = 0;
//        for (i = 0; i < n; i++)
//        {
//            //上半部分
//            int j = 0;
//            //先打印空格
//            for (j = 0; j < n - i; j++)
//                //如果这里要打印四个空格 4-0=4 三个空格4-1=3 两个空格4-2=2
//                //......
//            {
//                printf(" ");
//            }
//            //接下来打印 空格+星号
//            for (j = 0; j <= i; j++)
//                //因为这里j都是每次从0开始的 
//                //当i为0的时候打印零个 为1的时候打印一个 为2的时候打印两个
//                //......
//                //i随着变化而变化
//            {
//                printf("* ");
//            }
//            printf("\n");
//        }
//        //下半部分
//        //n+1 行
//        //依旧是有空格加型号组成的
//        for (i = 0; i < n + 1; i++)
//        {
//            int j = 0;
//            for (j = 0; j < i; j++)
//                //打印空格
//                //当i为0的时候不打印 当i为1的时候打印一个空格
//                //当i为2的时候打印两个 ......
//            {
//                printf(" ");
//            }
//            for (j = 0; j < n + 1 - i; j++)
//                //这里是因为是n+1行 所以要写成n+1
//                //这里是5的时候 i为0 就打印五个
//                //为4的时候 i为1 打印四个
//                //为3的时候 i为2 打印三个
//                //......
//            {
//                printf("* ");
//            }
//            printf("\n");
//        }
//
//    }
//
//    return 0;
//}

//int main() {
//	int a = 0;
//	int b = 0;
//	int c = 0;
//	while (scanf("%d", &a) != EOF)
//	{//打印上半部分跟打印下半部分；3+2
//		for (b = 0; b < a; b++)//打印 0 1 2 总共三行
//		{
//			for (c = 0; c < a - b - 1; c++)
//			{
//				printf(" ");
//			}
//			for (c = 0; c < b; c++)
//			{
//				printf("* ");
//			}
//			printf("\n");
//		}
//		for (b = 0; b < a - 1; b++)
//		{
//			for (c = 0; c <= b; c++)
//			{
//				printf(" ");
//			}
//			for (c = a - 1; c > 0; c--)
//			{
//				printf("* ");
//			}
//			printf("\n");
//		}
//
//	}
//	return 0;
//}


//sqrt(i)为i的平方；用于简化计算，比如i=a*b，则在2~i之间一定可以用a来整除i，用于提前判断；

//int main()
//{
//	int a = 0;
//	int b = 0;
//	int i = 0;
//	for (a = 1; a <= 9; a++)
//	{
//		for (b = 1; b <= a; b++)
//		{
//			i = a * b;
//			printf("%d*%d=%d  ", a, b, i);
//		}
//		printf("\n");
//	}
//
//
//
//
//	return 0;
//
//}


//求最大值，一个一个比较谁大接着比

//int main()
//{
//	int arr[10];
//	int max;
//	int i = 0;
//	for (i = 1; i <= 10; i++)
//	{
//		scanf("%d", arr);
//	}
//
//	max = arr[0];//数组下标为物理下标，第一个数为0；现设为最大值，后面在比较
//
//	for (i = 1; i <= 10; i++)
//	{
//		if (arr[i] < max)
//		{
//			max = arr[i];
//		}
//		printf("最大值为%d\n", max);
//
//
//
//
//
//
//
//	return 0;
//}



//调试时
//f11为语句调用表达式；逐语句，每一个函数都会进行调试，函数也不会放过；
//f10为逐过程，不会关注细节，函数直接结束过去，要看函数内部执行则按f11；


//打印从大到小输出的程序

//int main()
//{
//	int a = 0;
//	int b = 0;
//	int c = 0;
//	//赋值
//	scanf("%d%d%d", a, b, c);
//
//	//调整
//	if (a < b)
//	{
//		int tmp = a;
//		a = b;
//		b = tmp;//tmp为临时变量，用于储存最小值
//
//	}
//	if (a < c)
//	{
//		int tmp = a;
//		a = c;;
//		c = tmp;//tmp为临时变量，用于储存最小值
//
//	}
//	if (b < c)
//	{
//		int tmp = b;
//		b = c;;
//		c = tmp;//tmp为临时变量，用于储存最小值
//
//	}
//	printf("%d%d%d\n", a, b, c);
//
//	return 0;
//
//}
//
//
////打印两个数的最大公因数
//
//int main()
//{
//	int m = 0;
//	int n = 0;
//	scanf("%d%d", &m, &n);
//	int max;
//	if (m > n)
//		max = n;
//	else
//		max = m;
//	while (1)
//	{
//		if (m % max == 0 && n % max == 0)
//		{
//			printf("最大公约数为：%d\n", max);
//			break;
//		}
//		max--;
//	}
//
//
//
//
//
//	return 0;
//
//}
//
////辗转相除法
////步骤；有两个数 m n; 先用m% n == t; 将n赋给m, 将t赋给n, 继续这样，直到模为0才停止，最小公约数为t;
//
//
//int main()
//{
//	int a = 0;
//	int b = 0;
//	int t = 0;
//	scanf("%d%d", &a, &b);
//	while (a % b)//当a%b为0时自动停止；
//	{
//		t = a % b;//改进，直接把这个表达式赋给while的表达式；简化运算
//		a = b;
//		b = t;
//
//	}
//	printf("最大公约数：%d", &b);
//
//	//最小公倍数=a*b/最大公约数；
//	return 0;
//}
//
//int main()
//{
//	int a = 0; 
//	int b = 0;
//	int t = 0;
//	scanf("%d%d", &a, &b);
//	while (t % a == 0 && t % b == 0)
//	{
//		if (a > b)
//		{
//			t = a;
//		}
//		else
//		{
//			t = b;
//		}
//		t++;                                                                                                                                                                              
//	}
//
//
//}



 //打印100到200的数素

//先生成100到200的数，然后再进行对每个数值进行循环判断
#include <math.h>
//int main()
//{
//	int i = 0;
//	int count = 0;
//	for (i = 101; i <= 200; i+=2)//可以简化
//	{
//		int j = 0;
//		int flag = 1;//flag要放在变量i的循环内；否则无法使用
//		
//		for (j = 2; j < sqrt(i); j++)//还可以再简化；将i变为sqrt函数，这个函数为开平方函数；因为i=a*b，则肯定有a<i;使整除
//		{
//			if (i % j == 0)
//			{
//
//				flag = 0;
//				break;
//			}
//		}
//		if (flag == 1)//简化，在上面用一个变量假设i为数素
//		{
//			count++;
//			printf("%d ", i);
//		}
//	
//	}
//	printf("\n%d\n", count);
//
//
//
//	return 0;
//}



//库函数网站： /*www.cplusplus.com*/

//strcpy函数；交换两个数组的内容；char* strcpy(char* strDestination, const char* strSource);

#include <string.h>
//int main()
//{
//	char arr1[20] = {};
//	char arr2[] = "hello bit";
//	strcpy(arr1, arr2);
//	printf("%s", arr1);//打印字符arr1,以字符串格式打印
//
//
//	return 0;
//
//}
//第二个函数memset内存设置，mem = memory; char* strcpy(char* strDestination, const char* strSource);,将数组的前几个数字改变，如下代码/

//int main()
//{
//	char arr[] = "hello bit";
//	memset(arr, 'x', 5);//头文件为char *strcpy( char *strDestination, const char *strSource );
//
//	printf("%s\n", arr);//打印 出来是利用x来替代arr的前五个字符
//
//	return 0;
//}

//写一个函数交换2个整型变量的值；
//void swap2(int*pa,int*pb)
//{
//	int z = 0;
//	z = *pa;
//	*pa = *pb;
//	*pb = z;//用指针存放地址；
//	
//}
//
//int main()
//{
//
//
//	int a = 10;
//	int b = 20;
//	printf("交换前：a=%d b=%d\n", a, b);
//	swap2(&a, &b);//取地址调用到函数上
//	printf("交换后：a=%d b=%d\n", a, b);
//	return 0;
//}


//写一个函数判断闰年；
//int is_leap_year(int n)
//{
//	return((n % 4 == 0 && n % 100 != 0) || (n % 400 == 0));//对函数的调用，如果正确，则if 执行
//}
//int main()
//{
//	int y = 0;
//	for (y = 1000; y <= 2000; y++)//先生成年份
//	{
//		if (is_leap_year(y) == 1)
//		{
//			printf("%d ", y);
//		}
//	}
//	return 0;
//}
//
//int binary_search(int a[], int k, int s)
//{//数组的位置a[],,s为数组的个数，，K为key，到达的下标
//	int left = 0;
//	int right = s - 1;//从0到9；为10个数；所以要减一；
//	while (left <= right)
//	{
//		int mid = (left + right) / 2;
//		if (a[mid] > k)
//		{
//			right = mid - 1;
//		}
//		else if (a[mid] < k)
//		{
//			left = mid + 1;
//		}
//		else
//		{
//			return mid;
//		}
//	}
//
//	
//}
////遍历，二分查找法；
//int main()
//{
//	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
//	int key = 7;//寻找数组中下标为7的数；
//	//找到了就返回找到位置的下标
//	//找不到则返回-1
//	int sz = sizeof(arr) / sizeof(arr[0]);//不能把这个放在函数中，函数无法寻找到数组
//	int ret = binary_search(arr,key,sz);//对应的在函数调用中
//	if (-1 == ret)
//	{
//		printf("找不到\n");
//	}
//	else
//	{
//		printf("找到了，下标是：%d\n", ret);
//	}
//
//
//	return 0;
//}
//
////printf函数的返回值是一个整型；如
//int main()
//{
//	printf("%d", printf("%d", printf("%d", 43)));//打印值为4321；第一个打印为两个整型，第二次打印为2；第三次打印为1；
//	return 0;
//}
//
//
//
////函数可以嵌套使用，但是不能嵌套定义；
////链式访问
//
//int main()
//{
//	int len = strlen("abc");
//	printf("%d\n", strlen("abc"));//打印出来与写len一样；叫链式访问； 
//	return 0;
//}
//
//
////函数的声明和告知；函数定义在前面相当于强有力的声明；在后面则需要声明和告知‘
//
//
//int main()
//{
//	int a = 0;
//	int b = 0;
//	//无int ADD(int x,int y)声明时无法执行程序；
//	int ADD(int x, int y);//有声明时才可以调用； 
//	int c = ADD(a, b);
//	printf("%d", c);
//
//
//	return 0;
//}
//int ADD(int x, int y)
//{
//	return x + y;
// }
//
//
////集成代码开发存在头文件和源文件；定义头文件，利用源文件对头文件进行编译，然后要调用时采用对头文件说明即可； 
//对要开发的程序进行分布集成；先建立add.h,文件，在里面声明函数，再建立add.h文件，对函数进行解释；然后要调用函数为#include "add.h"即可；
//如：
//#include "add.h"
//int main()
//{
//	int a = 0; 
//	int b = 0;
//	int c = Add(a, b);
//	printf("%d\n", c);
//	return 0;
//}//这样即可调用函数add.h了

//如何让别人无法知道调用函数的源码；在此文件中点击3.30的属性，将常规中的配置类型改为静态库（.lib）,静态库打开为乱码二进制，无法看到源码，
//将头文件和静态库卖给别人，并在头文件中说明用法即可；要使用还需导入静态库；
//#pragma comment(lib,"sub.lib")即可


//递归，实质就是函数自身调用函数，
 
//void print(unsigned int n)
//{
//	if (n > 9)
//	{
//		print(n / 10);//先1234进来，然后一直调用除到1，然后再先执行打印1 ，再回到12的时候打印2 ,再回到123打印3，然后4.
//	}//n=1时函数已经执行完，返回调用时候的即可
//	printf("%d ", n % 10);
//}
//
//int main()
//{
//	unsigned int num = 0;
//	scanf("%u", &num);//123
//	print(num);//函数自身调用自身；
//
//	return 0;
//}
//
//
////每调用一个函数时都要占用栈区的一个空间，所以递归时可能出现栈溢出，//stack overflow,栈溢出。如
//
//void test(int i)
//{
//	if (i < 10000)
//	{
// 		test(i + 1);
//	}
//}
//int main()
//{
//	test(1);
//
//	return 0;
//}

//
//内存分为栈区，堆区，静态区
//栈区：局部变量，函数形参
//堆区：动态内存分配的malloc/free  calloc  realloc
//静态区：全局变量，静态变量
//
//使用递归的条件：1.不能死递归，都有跳出条件，每次递归逼近跳出条件 2. 递归层次不能太深，否则会进入死循环或者栈溢出；
//
//https://stackoverflow.com   程序员的知乎


//编写函数不允许创建临时变量，求字符串的长度
#include <string.h>

//int my_strlen(char* str)
//{
//	int count = 0;//创造了一个临时变量count，不符合。
//	while (*str != '\0')
//	{
//		count++;
//		str++;
//	}
//	return count;
//}
//
//int main()
//{
//	char arr[] = "bit";
//	printf("%d",my_strlen(arr));
//	return 0;
//}
//
//int my_strlen(char* str)
//{//利用去1然后再调用该函数进行下一个的判断是否为0；
//	if (*str != '\0')
//	{
//		return 1 + my_strlen(str+1);//这里为下一个的地址；返回指针的地址 
//	}
//	else
//		return 0;//当遇到\0时返回0，不在调用该函数；
//
//	
//}
//
//int main()
//{
//	char arr[] = "bit";
//	printf("%d", my_strlen(arr));
//	return 0;
//}




//循环也可称为迭代；如，编写一个n的阶乘；
//int main()
//{
//	int n = 0;
//	scanf("%d", &n);
//	int i = 0;
//	int ret = 1;
//	for (i = 1; i <= n; i++)
//	{
//		ret *= i;
//	}
//	printf("%d", ret);
//	return 0;
//}

//使用函数来求
//int Fac(int n)
//{
//	if (n <= 1)
//	{
//		return 1;
//	}
//	else
//	{
//		return n * Fac(n - 1);
//	}
//}
//int main()
//{
//	int n = 0;
//	scanf("%d", &n);
//	int ret = Fac(n);
//	printf("%d", ret);
//	return 0;
//}

//斐波那契函数，n > 2时，公式F(n - 1) + F(n - 2);
//效率低的算法
//递归
//int Fib(int n)
//{
//	if (n <= 2)
//	{
//		return 1;
//	}
//	else
//	{
//		return Fib(n - 1) + Fib(n - 2);
//	}
//}
//int main()
//{
//	int n = 0;
//	scanf("%d", &n);
//	int ret = Fib(n);
//		printf("%d", ret);
//
//	return 0;
//}

//简化运算，设abc,c为a+b,然后把c赋给b，再把b赋给a,这样就可以了；
//int Fib(int n)
//{
//	int a = 1;
//	int b = 1;
//	int c = 1;
//	while (n > 2)
//	{
//		c = a + b;
//		
//		a = b;//先把a赋给b才行，否则会被替换b 
//		b = c;
//		n--;//n--为循环进行的次数，并且循环能停下来；
//	}
//	return c;
//}
//int main()
//{
//	int n = 0;
//	scanf("%d", &n);
//	int ret = Fib(n);
//	printf("%d", ret);
//
//	return 0;
//}

//迭代比递归代码好用时，使用递归；
//经典问题：汉诺塔问题；青蛙跳台阶问题；


//编写程序数一下1到100的所有整数中出现多少个数字9；


//int main()
//{
//	int i = 0;
//	int count = 0;
//	for (i = 1; i <= 100; i++)
//	{
//		if (i % 10 == 9)
//			count++;
//		if (i / 10 == 9)
//			count++;
//	}
//	printf("%d", count);
//	return 0;
//}

//计算1/1-1/2+1/3..............+1/99;
//
//int main()
//{
//	int i = 0;
//	double sum = 0.0;
//	for (i = 1; i <= 100; i++)
//	{
//		if (i % 2 == 0)
//		{
//			sum -= 1.0 / i;
//		}
//		else
//		{
//			sum += 1.0 / i;
//		}
//	}printf("%lf\n", sum);
//
//		
//	return 0;
//}
//
////简单写法；
//
//int main()
//{
//	int i = 0;
//	double sum = 0.0;
//	int flag = 1;
//	for (i = 1; i <= 100; i++)
//	{
//		sum += flag * 1.0 / i;
//		flag = -flag;//利用-来达到隔一个为负号
//	}
//		printf("%lf\n", sum);
//	return 0;
//}
//
//栈区：存放 局部变量，函数参数，调用函数时返回值等临时的变量；
//堆区： 动态内存的分配；
//静态区： 全局变量，静态变量；

//编写程序交换数组中字符的位置；
//void reverse_string(char* str)
//{
//	int left = 0;
//	int right = strlen(str)-1;//调用了库函数strlen
//	while (left < right) {
//		char tmp = str[left];
//		str[left] = str[right];//加str[]是表示地址
//		str[right] = tmp;
//		left++;
//		right--;
//	}
//}
//
//int main()
//{
//	char arr[] = "abcdef";
//	reverse_string(arr);//存放地址，调用到函数中运行
//	printf("%s", arr);
//	return 0;
//}
//int my_strlen(char* str)
//{
//	int count = 0;
//	while (*str != '\0')
//	{
//		count++;
//		str++;
//	}
//	return count;
//}
//void reverse_string(char* str)
//{
//	int left = 0;
//	int right = my_strlen(str) - 1;
//	while (left < right) {
//		char tmp = str[left];//str[left]也可以写为*（str+left);表示left的地址；下面的同样可以改；
//		str[left] = str[right];//加str[]是表示地址
//		str[right] = tmp;
//		left++;
//		right--;
//	}
//}
//
//int main()
//{
//	char arr[] = "abcdef";
//	reverse_string(arr);//存放地址，调用到函数中运行
//	printf("%s", arr);
//	return 0;
//}

////递归
//int my_strlen(char* str)
//{
//	int count = 0;
//	while (*str != '\0')
//	{
//		count++;
//		str++;
//	}
//	return count;
//}
//void reverse_string(char* str)
//{
//	char tmp = *str;
//	int len = my_strlen(str);//
//	*str = *(str + len - 1);//长度指针，一开始str为0；读取最后一个字符，第一步，把a取出来，第二步，将f放到前面，第三步，把f的位置插为\0;,第四步，指向地址第二个，逆序中间的串bcde,第五步把a放上去
//	//把f 放到第一个位置
//	*(str + len - 1) = '\0';//这里是将替换的f插入\0；使他不在参与
//	//将最后一个设置为\0;
//	//在进行递归
//	if (my_strlen(str + 1) >= 2)//使用递归
//	{
//		reverse_string(str + 1);
//	}
//	*(str + len - 1) = tmp;//把a放到f上。
//}
//
//int main()
//{
//	char arr[] = "abcdef";
//	reverse_string(arr);//存放地址，调用到函数中运行
//	printf("%s", arr);
//	return 0;
//}

//时间戳srand((unsigned int)timt(NULL))头文件为time.h;保证调用一次就行；生成随机数
//如果两个字符串相等，strcmp函数会返回0；，两个字符比较时用这个函数；

//写一个关机程序；
//#include <string.h>
//int main()
//{
//
//	char input[20] = {0};
//	system("shutdown -s -t 60");
//again:
//	printf("即将关机，请输入我是猪\n");
//
//	scanf("%s", input);
//	if (strcmp(input, "我是猪") == 0)
//	{
//		system("shutdown -a");
//		printf("取消关机");
//	}
//	else {
//		goto again;
//	}
//
//
//	return 0;
//}

//猜数字程序；
//
#include <time.h>
//void menu()
//{
//	printf("******* 1.play 2.exit ******\n");
//}
//
//void game()
//{
//	int g = 0;
//	int r = rand() % 100 - 1;
//	while (1)
//	{
//		printf("请猜数字\n");
//		scanf("%d", &g);
//		if (g > r)
//		{
//			printf("猜大了\n");
//		}
//		else if (g < r)
//		{
//			printf("猜小了\n");
//		}
//		else
//		{
//			printf("猜对了\n");
//			break;
//		}
//	}
//}
//
//int main()
//{
//	int input = 0;
//	srand((unsigned int)time(NULL));
//	do
//	{
//		menu();
//		printf("请输入数字—>\n");
//		scanf("%d", &input);
//		switch (input)
//		{
//		case 1:
//			game();
//			break;
//		case 0:
//			printf("退出游戏!\n");
//			break;
//		default:
//			printf("输入错误，请重新选择\n");
//		}
//	} while (input);
//
//
//	return 0;
//}

//实现一个函数，打印乘法口诀表，口诀表的行数和列数自己指定
//如：输入9，输出9 * 9口诀表，输出12，输出12 * 12的乘法口诀表。

//int main()
//{
//
//	int i = 0;
//	int n = 0;
//	scanf("%d", &n);
//	for (i = 1; i <= n; i++)
//	{
//		int k = 0;
//		for (k = 1; k <= i; k++)
//		{
//			printf("%d*%d = %d ",i,k, i * k);
//		}
//		printf("\n");
//	}
//
//	return 0;
//}

//int binary_search(int a[], int k, int s)
//{//数组的位置a[],,s为数组的个数，，K为key，到达的下标
//	int left = 0;
//	int right = s - 1;//从0到9；为10个数；所以要减一；
//	while (left <= right)
//	{
//		int mid = (left + right) / 2;
//		if (a[mid] > k)
//		{
//			right = mid - 1;
//		}
//		else if (a[mid] < k)
//		{
//			left = mid + 1;
//		}
//		else
//		{
//			return mid;
//		}
//	}
//}
////遍历，二分查找法；
//int main()
//{
//	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
//	int key = 0;//寻找数组中下标为7的数；
//	scanf("%d", &key);
//	//找到了就返回找到位置的下标
//	//找不到则返回-1
//	int sz = sizeof(arr) / sizeof(arr[0]);//不能把这个放在函数中，函数无法寻找到数组//函数中无法调用这个数组，定义在main 函数中
//	int ret = binary_search(arr,key,sz);//对应的在函数调用中
//	if (-1 == ret)
//	{
//		printf("找不到\n");
//	}
//	else
//	{
//		printf("找到了，下标是：%d\n", ret);
//	}
//
//
//	return 0;
//}
//数组名既可以表示数组的地址，也可以表示数组首元素的地址，两个在数值上是一样的，但是含义不一样。
//注意：数组名只有在sizeof和& 后才代表整个数组，其它都表示首元素的地址
//写步骤
//1.先创建数组和所查找的下标数,2.再求出数组的长度值，3.创建一个函数将地址传入函数中；
//函数运行完进行判断，设置返回值为-1时则找不到，
//函数编辑，利用左右来判断

//int binary_search(int a[], int k, int sz)//.实际参数和形式参数可以同名
//{
//	int left = 0;
//	int right = sz - 1;
//	while (left <= right)
//{
//		int mid = (left + right) / 2;
//		if (a[mid] > k)
//		{
//		right = mid - 1;
//		}
//		else if (a[mid] < k)
//		{
//		left = mid + 1;
//		}
//		else
//		{
//		return mid;
//		}
//}
//}
//
//int main()
//{
//	int arr[] = { 1,2,3,4,5,6,7,8,9 };
//	int k = 7;
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	int r = binary_search(arr, k, sz);
//	if (-1 == r)
//			{
//				printf("找不到\n");
//			}
//			else
//			{
//				printf("找到了，下标是：%d\n", r);
//			}
//	return 0;
//}

//递归实现一个n的阶乘的函数；
//
//int Pow(int n, int k)
//{
//	if (k == 0)
//	{
//		return 1
//			;
//	}
//	if (k > 0)
//	{
//		return n * Pow(n, k - 1);
//	}
//}
//int main()
//{
//	int n = 0;
//	int k = 0;
//	scanf("%d %d", &n, &k);
//	int ret = Pow(n, k);
//	printf("%d", ret);
//	return 0;
//}

//数组在内存中是连续存放的，由低地址到高地址；数组有一维数组和二维数组


//变长数组，就是对数组进行编译，变长数组不能初始化
//
//int main()
//{
//	int n = 10;
//	int arr[n];//变长数组不能初始化
//
//	return 0;
//}
////strlen求字符串长度，不包括\0;sizeof包括\0，，，，，，，，
//
//#include <windows.h>
//#include <string.h>
//int main()
//{
//	char arr1[] = "welcoom to bit!!!!!!!!";
//	char arr2[] = "**********************";
//	int right = strlen(arr1) - 1;
//	//int right = sizeof(arr)/sizeof(arr[0]);/////这是在字符中，在int中不用
//	int left = 0;
//	while (left <= right)
//	{
//		arr2[left] = arr1[left];
//		arr2[right] = arr1[right];
//		printf("%s\0", arr2);
//		Sleep(1000);
//		system("cls");
//		right--;
//		left--;
//
//	}
//	return 0;
//}

//int main() {
//	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
//	int n = 7;
//	//在数组arr中找n的值，找到了就打印下标，找不到就打印:找不到//暴力的方法//对数组的元素进行遍历，拿n和每个元素进行比较
//	int i = 0;
//	int sz = sizeof(arr) / sizeof(arr[0]);//10
//	bool found = false;//假设没找到
//
//	for (i = 0; i < sz; i++)
//	{
//		if (n == arr[i])
//		{
//			printf("找到了，下标是:%d\n", i);
//			found = true;
//			break;
//		}
//	}
//	if (!found)
//		printf("找不到\n");
//	return 0;
//}


//输入年月输出日
bool is_leap_years(int x)//函数的声明中形式参数的名字可以省略
{
	if (((x % 4 == 0) && (x % 100 != 0)) || x % 400 == 0)
	{
		return true;
//	}
//	else
//		return false;
//}
//int get_days_of_mouth(int x, int y)
//{
//	int days[] = { 0,31,28,31,30,31,3,0,31,31,30,31,30,31 };
//	int d = days[y];
//	//闰年的判断；
//	if (is_leap_years(x) && y == 2)
//	{
//		d + 1;
//	}
//	return d;
//}
//int main()
//{
//	int year;
//	int mouth;
//	scanf("%d %d", &year, &mouth);
//	int r = get_days_of_mouth(year, mouth);
//	printf("%d", r);
//	return 0;
//}
////打印字符串的长度用zd或者zu,,一般推荐zu;
//
////.lib静态库     函数extern用来声明外部符号的；
//static是用来修饰局部变量的；将具有外部链接属性变成了内部链接属性，使这个全局变量只能在自己所在.c文件内部使用；
















